﻿using System;
using System.Collections.Concurrent;
using ORS.OrderRobot.IOC;
using ORS.OrderRobot.ServiceContracts;
using ORS.OrderRobot.ServiceContracts.Dtos;

namespace ORS.OrderRobot.Service.Request
{
	/// <summary>
	/// 代理池
	/// </summary>
	public class ProxyPool:IProxyPool, IScoped
    {
		// 使用 ConcurrentDictionary 存储代理信息，支持线程安全的添加和移除
    	private readonly ConcurrentDictionary<string, ProxyInfo> _proxies = new ConcurrentDictionary<string, ProxyInfo>();
		// 原子计数器，用于循环选择代理
		private volatile int _currentIndex = 0;
		
		public int Count => _proxies.Count;
		
		public ProxyPool()
		{
		}

		// 添加代理到池中
		public void AddProxy(ProxyInfo proxy)
		{
			if (proxy != null && !string.IsNullOrEmpty(proxy.Host))
			{
				// 使用 Host:Port 作为唯一键
				var key = $"{proxy.Host}:{proxy.Port}";
				_proxies.TryAdd(key, proxy);
			}
		}

		// 从池中移除代理
		public void RemoveProxy(ProxyInfo proxy)
		{
			if (proxy != null && !string.IsNullOrEmpty(proxy.Host))
			{
				var key = $"{proxy.Host}:{proxy.Port}";
				_proxies.TryRemove(key, out _);
			}
		}

		// 循环获取下一个代理（轮询策略）- 无锁实现
		public ProxyInfo? GetNextProxy()
		{
			if (_proxies.IsEmpty)
				return null;

			// 获取当前代理列表的快照
			var proxiesArray = _proxies.Values.ToArray();
			if (proxiesArray.Length == 0)
				return null;

			// 使用原子操作获取下一个索引
			var index = Interlocked.Increment(ref _currentIndex);
			
			// 处理整数溢出的情况，确保索引始终为正数
			if (index < 0)
			{
				Interlocked.Exchange(ref _currentIndex, 0);
				index = 0;
			}
			
			// 计算实际索引（循环）
			var actualIndex = index % proxiesArray.Length;
			
			return proxiesArray[actualIndex];
		}
		
		// 重置代理池 - 无锁实现
		public void Clear()
		{
			_proxies.Clear();
			Interlocked.Exchange(ref _currentIndex, 0);
		}
		
		// 获取所有代理的快照（用于调试或监控）
		public ProxyInfo[] GetAllProxies()
		{
			return _proxies.Values.ToArray();
		}
    }
}

